﻿#include<iostream>
using namespace std;

///////////////////////////////////
//初始化列表讲解：

//class B
//{
//public:
//	B(int b)
//	{
//		_b = b;
//	}
//private:
//	int _b;
//};

//class A
//{
//public:
//	A(int a1, int a2)//初始化列表：所有成员变量进行定义初始化的地方
//		:_a1(a1)//每个成员变量都只会出现在上面一次
//		//,_a1(a2)
//		, _a2(a2)
//		, _a3(1)
//		, _a4(1)
//		, _a5((int*)malloc(10))//也可以放在初始化列表
//		//初始化列表中成员变量是按照类中声明顺序来进行初始化的，和初始化列表顺序无关 
//		, _a6(1)
// //所以成员变量声明顺序和初始化列表中顺序要保持一致
//	{
//		//成员变量当然也可以在函数体内初始化
//		//函数体内就相当于下面这种：
//		//int i;
//		//i = 1;
//		//初始化列表中初始化就相当于：
//		//int i = 1;
//	}
//	//所以在成员变量初始化时尽量走初始化列表，即使不写初始化列表或者不在初始化列表上初始化的成员变量，它实际上还是会自动走初始化列表
//	//如果成员变量在声明时给了缺省值的话，初始化列表就会按照缺省值进行初始化
//	//所以以后成员变量初始化的时候一般都用初始化列表或者缺省值
//
//private:
//	int _a1 = 0;//可以给成员变量缺省值，这个缺省值其实就是给初始化列表的
//	int _a2 = 0;
//
//	//必须在初始化列表上初始化的成员变量
//	const int _a3;
//	const int& _a4;
//	//没有默认构造的自定义类型成员变量也必须在初始化列表上初始化
//	B _a6;
//
//	//指针成员变量
//	int* _a5 = (int*)malloc(10);
//
//	//注意事项：
//	//int i(1);//error
//	int i{ 1 };//可以用{}来初始化，不能用()
//};
//
//int main()
//{
//	A a1(1, 1);
//	return 0;
//}

//class B
//{
//public:
//	B(int b)
//	{
//		_b = b;
//	}
//private:
//	int _b;
//};
//
//
//class A
//{
//public:
//	A(int a1, int a2)
//		:_a1(a1)
//		, _a2(a2)
//		, _a3(1)
//		, _a4(1)
//		, _a5(1)
//	{
//	}
//private:
//	int _a1;
//	int _a2;
//	
//	//必须在初始化列表上初始化的成员变量
//	const int _a3;
//	const int& _a4;
//	//没有默认构造的自定义类型成员变量也必须在初始化列表上初始化
//	B _a5;
//};

//////////////////////////////////////
//类型转换

//class A
//{
//public:
//    //explicit A(int a)//加上explicit关键字，就不支持隐式类型转换
//    A(int a)//内置类型与自定义类型
//        :_a1(a)
//    {
//
//    }
//    A(int a1, int a2)
//        :_a1(a1)
//        , _a2(a2)
//    {
//
//    }
//    int Get() const
//    {
//        return _a1;
//    }
//private:
//    int _a1 = 1;
//    int _a2 = 1;
//};
//
//class B
//{
//public:
//	B(const A& a)
//		:_b(a.Get())
//	{}
//private:
//	int _b = 0;
//};
//
//int main()
//{
//    A a = 1;//构造函数+拷贝构造函数——>编译器优化为：直接构造函数
//    const A& a1 = 1;
//    A a2(1, 2);
//    B b = a;//原理和上面一样
//    return 0;
//}

//////////////////////////////////////
//static成员

//class A
//{
//public:
//	A()
//	{
//		a++;
//	}
//	void Print() const
//	{
//		cout << a << endl;
//	}
//	//static int GetA() const//静态成员函数不能使用类型限定符
//	static int GetA()
//	{
//		return a;
//	}
//private:
//	//类中声明
//	static int a;
//	//static int a = 1;//error:不能再类中初始化
//};

//类外初始化
//int A::a = 1;
//
//int main()
//{
//	/*cout << A::a << endl;*/
//	cout << A::GetA() << endl;
//	A a1;
//	a1.Print();
//	cout << a1.GetA() << endl;
//	A a2;
//	a2.Print();
//
//
//	return 0;
//}

///////////////////////////////////////////////
//内部类

//class A
//{
//public:
//	class B//内部类
//	{
//
//	};
//};
//
//int main()
//{
//	A::B b1;
//	cout << sizeof(A) << endl;
//	return 0;
//}


///////////////////////////////////////////////
//匿名对象

class A
{
public:
	A()
	:_a(1)
	{

	}
	int f1()
	{
		return _a;
	}
	void f2(const A& a = A())
	{

	}

private:
	int _a;
};

int main()
{
	//之前
	A a1;
	cout << a1.f1() << endl;
	//使用匿名对象
	cout << A().f1() << endl;

	const A& a2 = A();

	return 0;
}
